17 research outputs found
A coalgebraic perspective on minimization, determinization and behavioural metrics
Coalgebra offers a unified theory of state based systems, including infinite streams, labelled transition systems and deterministic automata. In this paper, we use the coalgebraic view on systems to derive, in a uniform way, abstract procedures for checking behavioural equivalence in coalgebras, which perform (a combination of) minimization and determinization in the system. First, we show that for coalgebras on categories equipped with factorization structures, there exists an abstract procedure for
equivalence checking. For instance, when considering epi-mono factorizations in the category of sets and functions, this procedure corresponds to the usual (coalgebraic) minimization algorithm and two states are behaviourally equivalent iff they are mapped to the same state in the minimized coalgebra. Second, motivated by several examples, we consider coalgebras on categories without suitable factorization structures: under certain conditions, it is possible to apply the above procedure after transforming coalgebras with reflections. This transformation can be thought of as some kind of determinization. Finally, we show that the result of the procedure also induces a pseudo-metric on the states, in such a way that the distance between each pair of states is minimized
Brzozowski's algorithm (co)algebraically
We give a new presentation of Brzozowski's algorithm to
minimize nite automata, using elementary facts from universal algebra
and coalgebra, and building on earlier work by Arbib and Manes on the
duality between reachability and observability. This leads to a simple
proof of its correctness and opens the door to further generalizations
A coalgebraic perspective on linear weighted automata
Weighted automata are a generalization of non-deterministic automata where each transition,
in addition to an input
letter, has also a quantity expressing the weight (e.g. cost or probability) of its
execution. As for non-deterministic
automata, their behaviours can be expressed in terms of either (weighted) bisimilarity
or (weighted) language equivalence.
Coalgebras provide a categorical framework for the uniform study of state-based systems
and their behaviours.
In this work, we show that coalgebras can suitably model weighted automata in two different
ways: coalgebras on
Set (the category of sets and functions) characterize weighted bisimilarity, while coalgebras on Vect (the category of
vector spaces and linear maps) characterize weighted language equivalence.
Relying on the second characterization, we show three different procedures for computing weighted language
equivalence. The first one consists in a generalizion of the usual partition refinement algorithm for ordinary automata.
The second one is the backward version of the first one. The third procedure relies on a syntactic representation of
rational weighted languages
Checking NFA equivalence with bisimulations up to congruence
16pInternational audienceWe introduce bisimulation up to congruence as a technique for proving language equivalence of non-deterministic finite automata. Exploiting this technique, we devise an optimisation of the classical algorithm by Hopcroft and Karp. We compare our algorithm to the recently introduced antichain algorithms, by analysing and relating the two underlying coinductive proof methods. We give concrete examples where we exponentially improve over antichains; experimental results moreover show non negligible improvements on random automata
Integrated Structure and Semantics for Reo Connectors and Petri Nets
In this paper, we present an integrated structural and behavioral model of
Reo connectors and Petri nets, allowing a direct comparison of the two
concurrency models. For this purpose, we introduce a notion of connectors which
consist of a number of interconnected, user-defined primitives with fixed
behavior. While the structure of connectors resembles hypergraphs, their
semantics is given in terms of so-called port automata. We define both models
in a categorical setting where composition operations can be elegantly defined
and integrated. Specifically, we formalize structural gluings of connectors as
pushouts, and joins of port automata as pullbacks. We then define a semantical
functor from the connector to the port automata category which preserves this
composition. We further show how to encode Reo connectors and Petri nets into
this model and indicate applications to dynamic reconfigurations modeled using
double pushout graph transformation
Choreographies with Secure Boxes and Compromised Principals
We equip choreography-level session descriptions with a simple abstraction of
a security infrastructure. Message components may be enclosed within (possibly
nested) "boxes" annotated with the intended source and destination of those
components. The boxes are to be implemented with cryptography. Strand spaces
provide a semantics for these choreographies, in which some roles may be played
by compromised principals. A skeleton is a partially ordered structure
containing local behaviors (strands) executed by regular (non-compromised)
principals. A skeleton is realized if it contains enough regular strands so
that it could actually occur, in combination with any possible activity of
compromised principals. It is delivery guaranteed (DG) realized if, in
addition, every message transmitted to a regular participant is also delivered.
We define a novel transition system on skeletons, in which the steps add
regular strands. These steps solve tests, i.e. parts of the skeleton that could
not occur without additional regular behavior. We prove three main results
about the transition system. First, each minimal DG realized skeleton is
reachable, using the transition system, from any skeleton it embeds. Second, if
no step is possible from a skeleton A, then A is DG realized. Finally, if a DG
realized B is accessible from A, then B is minimal. Thus, the transition system
provides a systematic way to construct the possible behaviors of the
choreography, in the presence of compromised principals
Coordination via Interaction Constraints I: Local Logic
Wegner describes coordination as constrained interaction. We take this
approach literally and define a coordination model based on interaction
constraints and partial, iterative and interactive constraint satisfaction. Our
model captures behaviour described in terms of synchronisation and data flow
constraints, plus various modes of interaction with the outside world provided
by external constraint symbols, on-the-fly constraint generation, and
coordination variables. Underlying our approach is an engine performing
(partial) constraint satisfaction of the sets of constraints. Our model extends
previous work on three counts: firstly, a more advanced notion of external
interaction is offered; secondly, our approach enables local satisfaction of
constraints with appropriate partial solutions, avoiding global synchronisation
over the entire constraints set; and, as a consequence, constraint satisfaction
can finally occur concurrently, and multiple parts of a set of constraints can
be solved and interact with the outside world in an asynchronous manner, unless
synchronisation is required by the constraints. This paper describes the
underlying logic, which enables a notion of local solution, and relates this
logic to the more global approach of our previous work based on classical
logic
Symbolic Implementation of Connectors in BIP
BIP is a component framework for constructing systems by superposing three
layers of modeling: Behavior, Interaction, and Priority. Behavior is
represented by labeled transition systems communicating through ports.
Interactions are sets of ports. A synchronization between components is
possible through the interactions specified by a set of connectors. When
several interactions are possible, priorities allow to restrict the
non-determinism by choosing an interaction, which is maximal according to some
given strict partial order.
The BIP component framework has been implemented in a language and a
tool-set. The execution of a BIP program is driven by a dedicated engine, which
has access to the set of connectors and priority model of the program. A key
performance issue is the computation of the set of possible interactions of the
BIP program from a given state.
Currently, the choice of the interaction to be executed involves a costly
exploration of enumerative representations for connectors. This leads to a
considerable overhead in execution times. In this paper, we propose a symbolic
implementation of the execution model of BIP, which drastically reduces this
overhead. The symbolic implementation is based on computing boolean
representation for components, connectors, and priorities with an existing BDD
package